पायथन ऑपरेटर मॉड्यूल: फंक्शनल प्रोग्रामिंगसाठी शक्तिशाली उपयुक्तता

प्रोग्रामिंगच्या जगात, विशेषतः फंक्शनल प्रोग्रामिंग पॅराडाइम्सचा अवलंब करताना, ऑपरेशन्स स्वच्छ, संक्षिप्त आणि पुन्हा वापरता येण्याजोग्या पद्धतीने व्यक्त करण्याची क्षमता अत्यंत महत्त्वाची आहे. पायथन, जरी प्रामुख्याने ऑब्जेक्ट-ओरिएंटेड भाषा असली तरी, फंक्शनल प्रोग्रामिंग शैलींसाठी मजबूत समर्थन देते. या समर्थनाचा एक महत्त्वाचा, पण कधीकधी दुर्लक्षित केलेला, घटक operator मॉड्यूलमध्ये आहे. हे मॉड्यूल पायथनच्या आंतरिक ऑपरेटर्सशी संबंधित कार्यक्षम फंक्शन्सचा संग्रह प्रदान करते, जे लॅम्डा फंक्शन्ससाठी उत्कृष्ट पर्याय म्हणून काम करतात आणि कोडची वाचनीयता व कार्यक्षमता वाढवतात.

operator मॉड्यूल समजून घेणे

operator मॉड्यूल पायथनच्या बिल्ट-इन ऑपरेटरच्या समतुल्य ऑपरेशन्स करणारी फंक्शन्स परिभाषित करते. उदाहरणार्थ, operator.add(a, b) हे a + b च्या समतुल्य आहे आणि operator.lt(a, b) हे a < b च्या समतुल्य आहे. ही फंक्शन्स त्यांच्या ऑपरेटर समकक्षांपेक्षा अधिक कार्यक्षम असतात, विशेषतः कार्यक्षमतेच्या दृष्टीने महत्त्वाच्या संदर्भांमध्ये, आणि map(), filter(), आणि functools.reduce() सारख्या फंक्शनल प्रोग्रामिंग स्ट्रक्चर्समध्ये त्यांची महत्त्वपूर्ण भूमिका असते.

तुम्ही ऑपरेटर थेट वापरण्याऐवजी operator मॉड्यूलमधील फंक्शन का वापराल? याची मुख्य कारणे अशी आहेत:

• फंक्शनल स्टाइल कंपॅटिबिलिटी: पायथनमधील अनेक हायर-ऑर्डर फंक्शन्स (जसे की functools मधील) कॉल करण्यायोग्य ऑब्जेक्ट्सची अपेक्षा करतात. ऑपरेटर फंक्शन्स कॉल करण्यायोग्य असल्याने, त्यांना स्वतंत्र लॅम्डा फंक्शन परिभाषित न करता ॲर्ग्युमेंट्स म्हणून पास करण्यासाठी ते योग्य आहेत.
• वाचनीयता: काही जटिल परिस्थितीत, नाविन्यपूर्ण ऑपरेटर फंक्शन्सचा वापर केल्याने गुंतागुंतीच्या लॅम्डा एक्स्प्रेशन्सपेक्षा कोडची स्पष्टता सुधारू शकते.
• कार्यक्षमता: काही ऑपरेशन्ससाठी, विशेषतः लूपमध्ये किंवा हायर-ऑर्डर फंक्शन्समध्ये वारंवार कॉल केल्यास, ऑपरेटर फंक्शन्स C मध्ये लागू केल्यामुळे थोडा कार्यक्षमतेचा फायदा देऊ शकतात.

मुख्य ऑपरेटर फंक्शन्स

operator मॉड्यूलचे ते दर्शवित असलेल्या ऑपरेशन्सच्या प्रकारानुसार व्यापक वर्गीकरण केले जाऊ शकते. चला, काही सर्वात सामान्यतः वापरल्या जाणाऱ्या फंक्शन्सचा शोध घेऊया.

अंकगणितीय ऑपरेटर

ही फंक्शन्स मानक अंकगणितीय गणना करतात. जेव्हा तुम्हाला अंकगणितीय ऑपरेशन दुसऱ्या फंक्शनला ॲर्ग्युमेंट म्हणून पास करण्याची आवश्यकता असते तेव्हा ती विशेषतः उपयुक्त ठरतात.

• operator.add(a, b): a + b च्या समतुल्य.
• operator.sub(a, b): a - b च्या समतुल्य.
• operator.mul(a, b): a * b च्या समतुल्य.
• operator.truediv(a, b): a / b च्या समतुल्य (खरे भागाकार).
• operator.floordiv(a, b): a // b च्या समतुल्य (फ्लोर भागाकार).
• operator.mod(a, b): a % b च्या समतुल्य (मॉड्युलो).
• operator.pow(a, b): a ** b च्या समतुल्य (घातांक).
• operator.neg(a): -a च्या समतुल्य (युनरी निगेशन).
• operator.pos(a): +a च्या समतुल्य (युनरी पॉझिटिव्ह).
• operator.abs(a): abs(a) च्या समतुल्य.

उदाहरण: operator.add चा functools.reduce सोबत वापर

कल्पना करा की तुम्हाला सूचीमधील सर्व घटकांची बेरीज करायची आहे. जरी sum() हा सर्वात पायथॉनिक मार्ग असला तरी, ऑपरेटर फंक्शनसह reduce वापरणे त्याची उपयुक्तता दर्शवते:

            import operator
from functools import reduce

numbers = [1, 2, 3, 4, 5]

# Using reduce with operator.add
total = reduce(operator.add, numbers)
print(f"The sum of {numbers} is: {total}") # Output: The sum of [1, 2, 3, 4, 5] is: 15

            

              
                Copy
              
            
          

हे कार्यात्मकदृष्ट्या याच्या समतुल्य आहे:

            total_lambda = reduce(lambda x, y: x + y, numbers)
print(f"Sum using lambda: {total_lambda}") # Output: Sum using lambda: 15

            

              
                Copy
              
            
          

operator.add आवृत्तीला अनेकदा तिच्या स्पष्टतेमुळे आणि संभाव्य कार्यक्षमतेच्या फायद्यांमुळे प्राधान्य दिले जाते.

तुलनात्मक ऑपरेटर

ही फंक्शन्स दोन ऑपरंड्समध्ये तुलना करतात.

• operator.lt(a, b): a < b च्या समतुल्य (पेक्षा कमी).
• operator.le(a, b): a <= b च्या समतुल्य (पेक्षा कमी किंवा बरोबर).
• operator.eq(a, b): a == b च्या समतुल्य (बरोबर).
• operator.ne(a, b): a != b च्या समतुल्य (बरोबर नाही).
• operator.ge(a, b): a >= b च्या समतुल्य (पेक्षा जास्त किंवा बरोबर).
• operator.gt(a, b): a > b च्या समतुल्य (पेक्षा जास्त).

उदाहरण: विशिष्ट की नुसार डिक्शनरीच्या सूचीची क्रमवारी लावणे

समजा तुमच्याकडे वापरकर्ता प्रोफाइलची एक सूची आहे, ज्यात प्रत्येक प्रोफाइल डिक्शनरीद्वारे दर्शविले आहे आणि तुम्हाला त्यांची 'score' नुसार क्रमवारी लावायची आहे.

            import operator

users = [
    {'name': 'Alice', 'score': 85},
    {'name': 'Bob', 'score': 92},
    {'name': 'Charlie', 'score': 78}
]

# Sort users by score using operator.itemgetter
sorted_users = sorted(users, key=operator.itemgetter('score'))
print("Users sorted by score:")
for user in sorted_users:
    print(user)
# Output:
# Users sorted by score:
# {'name': 'Charlie', 'score': 78}
# {'name': 'Alice', 'score': 85}
# {'name': 'Bob', 'score': 92}

            

              
                Copy
              
            
          

येथे, operator.itemgetter('score') हे एक कॉल करण्यायोग्य फंक्शन आहे, जे डिक्शनरी दिल्यावर, 'score' कीशी संबंधित मूल्य परत करते. key=lambda user: user['score'] लिहिण्यापेक्षा हे अधिक स्वच्छ आणि कार्यक्षम आहे.

बूलियन ऑपरेटर

ही फंक्शन्स लॉजिकल ऑपरेशन्स करतात.

• operator.not_(a): not a च्या समतुल्य.
• operator.truth(a): a सत्य असल्यास True परत करते, अन्यथा False.
• operator.is_(a, b): a is b च्या समतुल्य.
• operator.is_not(a, b): a is not b च्या समतुल्य.

उदाहरण: फसलेल्या मूल्यांना फिल्टर करणे

तुम्ही filter() सह operator.truth वापरून इटरेबलमधून सर्व फसलेली मूल्ये (जसे की 0, None, रिकाम्या स्ट्रिंग, रिकाम्या सूची) काढू शकता.

            import operator

data = [1, 0, 'hello', '', None, [1, 2], []]

# Filter out falsy values using operator.truth
filtered_data = list(filter(operator.truth, data))
print(f"Original data: {data}")
print(f"Filtered data (truthy values): {filtered_data}")
# Output:
# Original data: [1, 0, 'hello', '', None, [1, 2], []]
# Filtered data (truthy values): [1, 'hello', [1, 2]]

            

              
                Copy
              
            
          

बिटवाइझ ऑपरेटर

ही फंक्शन्स पूर्णांकांच्या वैयक्तिक बिट्सवर कार्य करतात.

• operator.and_(a, b): a & b च्या समतुल्य.
• operator.or_(a, b): a | b च्या समतुल्य.
• operator.xor(a, b): a ^ b च्या समतुल्य.
• operator.lshift(a, b): a << b च्या समतुल्य.
• operator.rshift(a, b): a >> b च्या समतुल्य.
• operator.invert(a): ~a च्या समतुल्य.

उदाहरण: बिटवाइझ ऑपरेशन्स करणे

            import operator

a = 10 # Binary: 1010
b = 4  # Binary: 0100

print(f"a & b: {operator.and_(a, b)}") # Output: a & b: 0 (Binary: 0000)
print(f"a | b: {operator.or_(a, b)}")  # Output: a | b: 14 (Binary: 1110)
print(f"a ^ b: {operator.xor(a, b)}") # Output: a ^ b: 14 (Binary: 1110)
print(f"~a: {operator.invert(a)}")     # Output: ~a: -11

            

              
                Copy
              
            
          

अनुक्रम आणि मॅपिंग ऑपरेटर

ही फंक्शन्स अनुक्रमांमधील (उदा. सूची, ट्यूपल, स्ट्रिंग्स) आणि मॅपिंग्जमधील (उदा. डिक्शनरी) घटकांमध्ये प्रवेश करण्यासाठी उपयुक्त आहेत.

• operator.getitem(obj, key): obj[key] च्या समतुल्य.
• operator.setitem(obj, key, value): obj[key] = value च्या समतुल्य.
• operator.delitem(obj, key): del obj[key] च्या समतुल्य.
• operator.len(obj): len(obj) च्या समतुल्य.
• operator.concat(a, b): a + b च्या समतुल्य (स्ट्रिंग्स किंवा सूची सारख्या अनुक्रमांसाठी).
• operator.contains(obj, item): item in obj च्या समतुल्य.

operator.itemgetter: एक शक्तिशाली साधन

क्रमवारी लावण्याच्या उदाहरणात सूचित केल्याप्रमाणे, operator.itemgetter हे एक विशेष फंक्शन आहे जे अविश्वसनीयपणे उपयुक्त आहे. जेव्हा ते एक किंवा अधिक ॲर्ग्युमेंट्ससह कॉल केले जाते, तेव्हा ते एक कॉल करण्यायोग्य फंक्शन परत करते जे त्याच्या ऑपरंडमधून ते आयटम्स आणते. जर अनेक ॲर्ग्युमेंट्स दिली असतील, तर ते आणलेल्या आयटम्सचा ट्यूपल परत करते.

            import operator

# Fetching a single item
get_first_element = operator.itemgetter(0)
my_list = [10, 20, 30]
print(f"First element: {get_first_element(my_list)}") # Output: First element: 10

# Fetching multiple items
get_first_two = operator.itemgetter(0, 1)
print(f"First two elements: {get_first_two(my_list)}") # Output: First two elements: (10, 20)

# Fetching items from a dictionary
get_name_and_score = operator.itemgetter('name', 'score')
user_data = {'name': 'Alice', 'score': 85, 'city': 'New York'}
print(f"User info: {get_name_and_score(user_data)}") # Output: User info: ('Alice', 85)

            

              
                Copy
              
            
          

operator.itemgetter हे क्रमवारी लावताना किंवा की फंक्शन स्वीकारणाऱ्या इतर फंक्शन्समध्ये key ॲर्ग्युमेंट म्हणून वापरल्यास ते खूप कार्यक्षम असते.

operator.attrgetter: ॲट्रिब्यूट्समध्ये प्रवेश करणे

itemgetter प्रमाणेच, operator.attrgetter एक कॉल करण्यायोग्य फंक्शन परत करते जे त्याच्या ऑपरंडमधून ॲट्रिब्यूट्स आणते. ऑब्जेक्ट्ससह कार्य करताना हे विशेषतः उपयुक्त आहे.

            import operator

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

products = [
    Product('Laptop', 1200),
    Product('Mouse', 25),
    Product('Keyboard', 75)
]

# Get all product names
get_name = operator.attrgetter('name')
product_names = [get_name(p) for p in products]
print(f"Product names: {product_names}") # Output: Product names: ['Laptop', 'Mouse', 'Keyboard']

# Sort products by price
sorted_products = sorted(products, key=operator.attrgetter('price'))
print("Products sorted by price:")
for p in sorted_products:
    print(f"- {p.name}: ${p.price}")
# Output:
# Products sorted by price:
# - Mouse: $25
# - Keyboard: $75
# - Laptop: $1200

            

              
                Copy
              
            
          

attrgetter डॉट नोटेशन वापरून नेस्टेड ऑब्जेक्ट्समधील ॲट्रिब्यूट्समध्ये देखील प्रवेश करू शकते. उदाहरणार्थ, operator.attrgetter('address.city') ऑब्जेक्टच्या 'address' ॲट्रिब्यूटमधून 'city' ॲट्रिब्यूट आणेल.

इतर उपयुक्त फंक्शन्स

• operator.methodcaller(name, *args, **kwargs): एक कॉल करण्यायोग्य फंक्शन परत करते जे त्याच्या ऑपरंडवरील name नावाच्या पद्धतीला कॉल करते. ही itemgetter आणि attrgetter च्या पद्धतीची समतुल्य आहे.

उदाहरण: सूचीमधील ऑब्जेक्ट्सवर पद्धत कॉल करणे

            import operator

class Greeter:
    def __init__(self, name):
        self.name = name

    def greet(self, message):
        return f"{self.name} says: {message}"

greeters = [Greeter('Alice'), Greeter('Bob')]

# Call the greet method on each Greeter object
call_greet = operator.methodcaller('greet', 'Hello from the operator module!')

greetings = [call_greet(g) for g in greeters]
print(greetings)
# Output: ['Alice says: Hello from the operator module!', 'Bob says: Hello from the operator module!']

            

              
                Copy
              
            
          

फंक्शनल प्रोग्रामिंग संदर्भांमध्ये operator मॉड्यूल

operator मॉड्यूलची खरी शक्ती पायथनच्या बिल्ट-इन फंक्शनल प्रोग्रामिंग टूल्स जसे की map(), filter(), आणि functools.reduce() सोबत वापरल्यास दिसून येते.

map() आणि operator

map(function, iterable, ...)` इटरेबलच्या प्रत्येक आयटमवर फंक्शन लागू करते आणि परिणामांचा इटरेटर परत करते. ऑपरेटर फंक्शन्स यासाठी योग्य आहेत.

            import operator

numbers = [1, 2, 3, 4, 5]

# Square each number using map and operator.mul
squared_numbers = list(map(lambda x: operator.mul(x, x), numbers)) # Can be simpler: list(map(operator.mul, numbers, numbers)) or list(map(pow, numbers, [2]*len(numbers)))
print(f"Squared numbers: {squared_numbers}") # Output: Squared numbers: [1, 4, 9, 16, 25]

# Add 10 to each number using map and operator.add
added_ten = list(map(operator.add, numbers, [10]*len(numbers)))
print(f"Numbers plus 10: {added_ten}") # Output: Numbers plus 10: [11, 12, 13, 14, 15]

            

              
                Copy
              
            
          

            import operator

salaries = [50000, 65000, 45000, 80000, 70000]

# Filter salaries greater than 60000
high_salaries = list(filter(operator.gt, salaries, [60000]*len(salaries)))
print(f"Salaries above 60000: {high_salaries}") # Output: Salaries above 60000: [65000, 80000, 70000]

# Filter even numbers using operator.mod and lambda (or a more complex operator function)
even_numbers = list(filter(lambda x: operator.eq(operator.mod(x, 2), 0), [1, 2, 3, 4, 5, 6]))
print(f"Even numbers: {even_numbers}") # Output: Even numbers: [2, 4, 6]

            

              
                Copy
              
            
          

            import operator
from functools import reduce

numbers = [2, 3, 4, 5]

# Calculate the product of numbers
product = reduce(operator.mul, numbers)
print(f"Product: {product}") # Output: Product: 120

# Find the maximum number
maximum = reduce(operator.gt, numbers)
print(f"Maximum: {maximum}") # This doesn't work as expected for max, need to use a lambda or custom function for max: 
# Using lambda for max:
maximum_lambda = reduce(lambda x, y: x if x > y else y, numbers)
print(f"Maximum (lambda): {maximum_lambda}") # Output: Maximum (lambda): 5
# Note: The max() built-in function is generally preferred for finding the maximum.

            

              
                Copy